Here's the list with the additional points:

1. Ensure that you have OpenJDK 17, Android Studio, and its associated tools and NDK (Native Development Kit) installed on your system.

2. Initialize a new Expo project by executing the following command in your terminal: pnpm create expo-app@latest. This command will prompt you to provide some details about your project, such as the project name and configuration options.

3. Before building the Android app, you need to prebuild the android directory. Run the command pnpm expo prebuild to generate the necessary files. Additionally, you should provide your app's package name during this step. For example, if your app's package name is com.example.app.

4. Generate a keystore file. Use an administrator shell to create the keystore. Run the following command: keytool -genkeypair -v -storetype PKCS12 -keystore my-upload-key.keystore -alias my-key-alias -keyalg RSA -keysize 2048 -validity 10000 and enter your password (store it safely somewhere) and details.

A pattern for building personal knowledge bases using LLMs.

This is an idea file, it is designed to be copy pasted to your own LLM Agent (e.g. OpenAI Codex, Claude Code, OpenCode / Pi, or etc.). Its goal is to communicate the high level idea, but your agent will build out the specifics in collaboration with you.

Most people's experience with LLMs and documents looks like RAG: you upload a collection of files, the LLM retrieves relevant chunks at query time, and generates an answer. This works, but the LLM is rediscovering knowledge from scratch on every question. There's no accumulation. Ask a subtle question that requires synthesizing five documents, and the LLM has to find and piece together the relevant fragments every time. Nothing is built up. NotebookLM, ChatGPT file uploads, and most RAG systems work this way.

Prompts to recreate each piece of the OpenClaw system. Use these with any AI coding assistant.

1. Personal CRM "Build a personal CRM that automatically scans my Gmail and Google Calendar to discover contacts from the past year. Store them in a SQLite database with vector embeddings so I can query in natural language ('who do I know at NVIDIA?' or 'who haven't I talked to in a while?'). Auto-filter noise senders like marketing emails and newsletters. Build profiles for each contact with their company, role, how I know them, and our interaction history. Add relationship health scores that flag stale relationships, follow-up reminders I can create, snooze, or mark done, and duplicate contact detection with merge suggestions. Link relevant documents from Box to contacts so when I look up a person, I also see related docs."

2. Meeting Action Items (Fathom)

This document outlines the architecture for a centralized notification service designed to deliver Push, SMS, and Email notifications to an active user base of 1M+ users. The system is engineered for high reliability, guaranteeing zero missed sends, exactly-once processing (idempotency), and graceful degradation in the event of third-party provider outages.

• Expose an internal API for microservices to enqueue notifications.
• Support multiple delivery channels: Email (e.g., SendGrid), SMS (e.g., Twilio), and Push (e.g., FCM/APNs).

This document defines how you work. It is not a suggestion. It is a protocol. Violating it produces noise, not signal.

The fundamental principle: EVIDENCE FIRST, ALWAYS. You do not choose approaches because they seem reasonable. You do not write code because you suspect it might work. You do not change the project structure because results disappointed you. Every decision flows from evidence. If you don't have evidence to justify a decision, your next action produces that evidence. Nothing else.

Sycophancy is the enemy. The user does not benefit from code that looks right. The user benefits from code that IS right, and from an agent that can PROVE it is right at every step. Your job is not to produce output that satisfies. Your job is to produce output that works, and to demonstrate that it works through verification, not assertion.

Foundation offers a Thread class, internally based on pthread, that can be used to create new threads and execute closures.

// Detaches a new thread and uses the specified selector as the thread entry point.
Thread.detachNewThreadSelector(selector: Selector>, toTarget: Any, with: Any)

// Subclass
class MyThread: Thread {